library(nycflights13)
library(tidyverse)
[30m-- [1mAttaching packages[22m --------------------------------------- tidyverse 1.2.1 --[39m
[30m[32mv[30m [34mggplot2[30m 3.0.0 [32mv[30m [34mpurrr [30m 0.2.5
[32mv[30m [34mtibble [30m 1.4.2 [32mv[30m [34mdplyr [30m 0.7.6
[32mv[30m [34mtidyr [30m 0.8.1 [32mv[30m [34mstringr[30m 1.3.1
[32mv[30m [34mreadr [30m 1.1.1 [32mv[30m [34mforcats[30m 0.3.0[39m
[30m-- [1mConflicts[22m ------------------------------------------ tidyverse_conflicts() --
[31mx[30m [34mdplyr[30m::[32mfilter()[30m masks [34mstats[30m::filter()
[31mx[30m [34mdplyr[30m::[32mlag()[30m masks [34mstats[30m::lag()[39m
Filter Rows
# filter by flights on the 1st of january
(jan1 <- filter(flights, month == 1, day == 1))
Comparisons
sqrt(2) ^ 2 == 2
[1] FALSE
1 / 49 * 49 == 1
[1] FALSE
near(sqrt(2) ^ 2, 2)
[1] TRUE
near(1 / 49 * 49, 1)
[1] TRUE
Logical operators
(nov_dec <- filter(flights, month == 11 | month == 12))
# using shorthand
(nov_dec <- filter(flights, month %in% c(11, 12)))
# using demorgan's
(delay_range1 <- filter(flights, !(arr_delay > 120 | dep_delay > 120)))
Missing Values
NA > 5
[1] NA
10 == NA
[1] NA
NA == NA
[1] NA
x <- NA
is.na(x)
[1] TRUE
df <- tibble(x = c(1, NA, 3))
filter(df, x > 1)
filter(df, is.na(x) | x > 1)
Exercises
# 1
filter(flights, arr_delay >= 120)
filter(flights, dest == "IAH" | dest == "HOU")
filter(flights, carrier == "UA" | carrier == "AA" | carrier == "DL")
filter(flights, month %in% c(7, 8, 9))
filter(flights, dep_delay <= 0, arr_delay > 120)
filter(flights, dep_delay >= 60, dep_delay - arr_delay > 30)
filter(flights, between(dep_time, 0, 600) | dep_time == 2400)
filter(flights, is.na(dep_time))
Arrange Rows
arrange(flights, year, month, day)
arrange(flights, desc(dep_delay))
arrange(flights, dep_delay)
# Missing values are always sorted at the end
df <- tibble(x = c(5, 2, NA))
arrange(df, x)
arrange(df, desc(x))
Exercises
# 1
arrange(flights, desc(is.na(dep_time)), dep_time)
# 2
# Most delayed
arrange(flights, desc(dep_delay))
# Earliest
arrange(flights, dep_delay)
# 3
# total air time
arrange(flights, air_time)
# average air time
arrange(flights, distance / air_time * 60)
# 4
# interpretation 1
arrange(flights, desc(distance))
arrange(flights, distance)
# interpretation 2
arrange(flights, desc(air_time))
arrange(flights, air_time)
Select Columns
select(flights, year, month, day)
# Select range of columns
select(flights, year:day)
# Exclude columns
select(flights, -(year:day))
rename(flights, tail_num = tailnum)
# Move some variables to the start of the dataframe
select(flights, time_hour, air_time, everything())
Exercises
# 1
select(flights, dep_time, dep_delay, arr_time, arr_delay)
select(flights, "dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, starts_with("dep_"), starts_with("arr_"))
select(flights, 4, 6, 7, 9)
select(flights, matches("^(dep|arr)_(delay|time)$"))
of_interest <- c("dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, one_of(of_interest))
# 2
select(flights, dep_time, dep_time)
# 4
select(flights, contains("TIME"))
select(flights, contains("TIME", ignore.case = FALSE))
Add new variables
(flights_sml <- select(
flights,
year:day,
ends_with("delay"),
distance,
air_time
))
# add some columns
(mutate(
flights_sml,
gain = dep_delay - arr_delay,
speed = distance / air_time * 60
))
# Use new columns for an opperation
(mutate(
flights_sml,
gain = dep_delay - arr_delay,
hours = air_time / 60,
gain_per_hour = gain / hours
))
# Only keep the new variables
(transmute(
flights,
gain = dep_delay - arr_delay,
hours = air_time / 60,
gain_per_hour = gain / hours
))
# Using other functions
(transmute(
flights,
dep_time,
hour = dep_time %/% 100,
minute = dep_time %% 100
))
# Lag and Lead
(x <- 1:10)
[1] 1 2 3 4 5 6 7 8 9 10
lag(x)
[1] NA 1 2 3 4 5 6 7 8 9
lead(x)
[1] 2 3 4 5 6 7 8 9 10 NA
# Running aggregates
cumsum(x)
[1] 1 3 6 10 15 21 28 36 45 55
cummean(x)
[1] 1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0 5.5
# Ranking
y <- c(2, 3, 3, NA, 4, 7)
min_rank(y)
[1] 1 2 2 NA 4 5
min_rank(desc(y))
[1] 5 3 3 NA 2 1
row_number(y)
[1] 1 2 3 NA 4 5
dense_rank(y)
[1] 1 2 2 NA 3 4
cume_dist(y)
[1] 0.2 0.6 0.6 NA 0.8 1.0
Exercises
# 1
# Midnight is represented as 2400 -> 24 * 60 = 1440 minutes after midnight (need to account for this)
time_to_mins <- function(t) {
return((t %/% 100 * 60 + t %% 100) %% 1440)
}
(flight_times <- mutate(
flights,
dep_time_mins = time_to_mins(dep_time),
sched_dep_time_mins = time_to_mins(sched_dep_time)
))
select(flight_times, dep_time, sched_dep_time, dep_time_mins, sched_dep_time_mins)
# 2
# Grab rows of interest
(flight_durs <- select(flights, arr_time, dep_time, air_time, origin, dest))
# Convert them all to minutes (except air time, which already is)
(flight_durs <- mutate(
flight_durs,
arr_time_mins = time_to_mins(arr_time),
dep_time_mins = time_to_mins(dep_time)
))
# Rearrange columns
flight_durs <- select(flight_durs, origin, dest, air_time, everything())
# Calculate air_time_diff
(flight_durs <- mutate(flight_durs, air_time_diff = arr_time_mins - dep_time_mins))
# Check if it worked. Are there negatives?
arrange(flight_durs, air_time_diff)
# There are, so flights that go overnight are incorrect. Also, timezones could cause problems
# 3
# SHould be difference between dep time and scheduled dep time
flights_deptime <-
mutate(
flights,
dep_time_mins = time_to_mins(dep_time),
sched_dep_time_mins = time_to_mins(sched_dep_time),
dep_delay_mins = dep_time_mins - sched_dep_time_mins
)
# Have same issue that overnight delays appear as <= 0
Exercises (cont.)
# 4
(most_delayed <- select(
mutate(
flights,
dep_delay_rank = min_rank(desc(dep_delay))
),
dep_delay_rank,
dep_delay,
everything()
)
)
arrange(most_delayed, dep_delay)
# Only grab the 50 most delayed (there are no repeats in the top 10)
(top_50 <- arrange(
filter(most_delayed, dep_delay_rank <= 50),
dep_delay_rank)
)
# 5
1:3 + 1:10
longer object length is not a multiple of shorter object length
[1] 2 4 6 5 7 9 8 10 12 11
Grouped Summaries
summarise(flights, delay = mean(dep_delay, na.rm = TRUE))
by_day <- group_by(flights, year, month, day)
summarize(by_day, delay = mean(dep_delay, na.rm = TRUE))
# Group flights by destination
by_dest <- group_by(flights, dest)
# Summarize distance, avg. delay, number of flights
(delays <- summarize(
by_dest,
count = n(),
dist = mean(distance, na.rm = TRUE),
delay = mean(arr_delay, na.rm = TRUE)
))
# Honolulu is quite far away from all others
arrange(delays, desc(dist))
# Ignore destinations that rarely occur
arrange(delays, count)
# Filter to remove noise (I.E. Honolulu and destinations with a very small number of flights)
(delays <- filter(delays, count > 20, dest != "HNL"))
# Visualize the data
ggplot(data = delays, mapping = aes(x = dist, y = delay)) +
geom_point(aes(size = count), alpha = 1/3) +
geom_smooth(se = FALSE)

# Do the same thing using pipes
# Note: x %>% f(y) == f(x, y) and x %>% f(y) %>% g(z) == g(f(x, y), z)
(delays <- flights %>%
group_by(dest) %>%
summarize(
count = n(),
dist = mean(distance, na.rm = TRUE),
delay = mean(arr_delay, na.rm = TRUE)
) %>%
filter(count > 20, dest != "HNL") %>%
arrange(desc(delay))
)
# Reason for using na.rm
flights %>%
group_by(year, month, day) %>%
summarize(mean = mean(dep_delay))
# Fixed
flights %>%
group_by(year, month, day) %>%
summarize(mean = mean(dep_delay, na.rm = TRUE))
# Remove cancelled flights from the data set
not_cancelled <- flights %>%
filter(!is.na(dep_delay), !is.na(arr_delay))
not_cancelled %>%
group_by(year, month, day) %>%
summarize(mean = mean(dep_delay))
Grouped Summaries (cont.)
# Find individual planes (identified by tail num) and their average delays
delays <- not_cancelled %>%
group_by(tailnum) %>%
summarize(
delay = mean(arr_delay)
)
ggplot(data = delays, mapping = aes(x = delay)) +
geom_freqpoly(binwidth = 10)

# Try with number of flights vs avg delay
delays <- not_cancelled %>%
group_by(tailnum) %>%
summarize(
delay = mean(arr_delay),
n = n()
)
ggplot(data = delays, mapping = aes(x = n, y = delay)) +
geom_point(alpha = 1/10)

---
title: "Chapter 5"
output: html_notebook
---


```{r}
library(nycflights13)
library(tidyverse)
```

# nycflights13
```{r}
flights
```

# Filter Rows
```{r}
# filter by flights on the 1st of january
(jan1 <- filter(flights, month == 1, day == 1))
```

# Comparisons
```{r}
sqrt(2) ^ 2 == 2
1 / 49 * 49 == 1
near(sqrt(2) ^ 2, 2)
near(1 / 49 * 49, 1)

```

# Logical operators
```{r}
(nov_dec <- filter(flights, month == 11 | month == 12))

# using shorthand
(nov_dec <- filter(flights, month %in% c(11, 12)))
# using demorgan's
(delay_range1 <- filter(flights, !(arr_delay > 120 | dep_delay > 120)))
```

# Missing Values
```{r}
NA > 5
10 == NA
NA == NA
x <- NA
is.na(x)
df <- tibble(x = c(1, NA, 3))
filter(df, x > 1)
filter(df, is.na(x) | x > 1)
```

# Exercises
```{r}
# 1
filter(flights, arr_delay >= 120)
filter(flights, dest == "IAH" | dest == "HOU")
filter(flights, carrier == "UA" | carrier == "AA" | carrier == "DL")
filter(flights, month %in% c(7, 8, 9))
filter(flights, dep_delay <= 0, arr_delay > 120)
filter(flights, dep_delay >= 60, dep_delay - arr_delay > 30)
filter(flights, between(dep_time, 0, 600) | dep_time == 2400)
filter(flights, is.na(dep_time))
```

# Arrange Rows
```{r}
arrange(flights, year, month, day)
arrange(flights, desc(dep_delay))
arrange(flights, dep_delay)

# Missing values are always sorted at the end
df <- tibble(x = c(5, 2, NA))
arrange(df, x)
arrange(df, desc(x))
```

# Exercises
```{r}
# 1
arrange(flights, desc(is.na(dep_time)), dep_time)
# 2
# Most delayed
arrange(flights, desc(dep_delay))
# Earliest
arrange(flights, dep_delay)
# 3
# total air time
arrange(flights, air_time)
# average air time
arrange(flights, distance / air_time * 60)
# 4
# interpretation 1
arrange(flights, desc(distance))
arrange(flights, distance)
# interpretation 2
arrange(flights, desc(air_time))
arrange(flights, air_time)
```

# Select Columns
```{r}
select(flights, year, month, day)
# Select range of columns
select(flights, year:day)
# Exclude columns
select(flights, -(year:day))
rename(flights, tail_num = tailnum)
# Move some variables to the start of the dataframe
select(flights, time_hour, air_time, everything())
```

# Exercises
```{r}
# 1
select(flights, dep_time, dep_delay, arr_time, arr_delay)
select(flights, "dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, starts_with("dep_"), starts_with("arr_"))
select(flights, 4, 6, 7, 9)
select(flights, matches("^(dep|arr)_(delay|time)$"))
of_interest <- c("dep_time", "dep_delay", "arr_time", "arr_delay")
select(flights, one_of(of_interest))
# 2
select(flights, dep_time, dep_time)

# 4
select(flights, contains("TIME"))
select(flights, contains("TIME", ignore.case = FALSE))
```

# Add new variables
```{r}
(flights_sml <- select(
  flights,
  year:day,
  ends_with("delay"),
  distance,
  air_time
))

# add some columns
(mutate(
  flights_sml,
  gain = dep_delay - arr_delay,
  speed = distance / air_time * 60
))

# Use new columns for an opperation
(mutate(
  flights_sml,
  gain = dep_delay - arr_delay,
  hours = air_time / 60,
  gain_per_hour = gain / hours
))

# Only keep the new variables
(transmute(
  flights,
  gain = dep_delay - arr_delay,
  hours = air_time / 60,
  gain_per_hour = gain / hours
))

# Using other functions
(transmute(
  flights,
  dep_time,
  hour = dep_time %/% 100,
  minute = dep_time %% 100
))

# Lag and Lead
(x <- 1:10)
lag(x)
lead(x)

# Running aggregates
cumsum(x)
cummean(x)

# Ranking
y <- c(2, 3, 3, NA, 4, 7)
min_rank(y)
min_rank(desc(y))
row_number(y)
dense_rank(y)
cume_dist(y)
```

# Exercises
```{r}
# 1
# Midnight is represented as 2400 -> 24 * 60 = 1440 minutes after midnight (need to account for this)
time_to_mins <- function(t) {
  return((t %/% 100 * 60 + t %% 100) %% 1440)
}

(flight_times <- mutate(
  flights,
  dep_time_mins = time_to_mins(dep_time),
  sched_dep_time_mins = time_to_mins(sched_dep_time)
))

select(flight_times, dep_time, sched_dep_time, dep_time_mins, sched_dep_time_mins)

# 2
# Grab rows of interest
(flight_durs <- select(flights, arr_time, dep_time, air_time, origin, dest))
# Convert them all to minutes (except air time, which already is)
(flight_durs <- mutate(
  flight_durs,
  arr_time_mins = time_to_mins(arr_time),
  dep_time_mins = time_to_mins(dep_time)
))
# Rearrange columns
flight_durs <- select(flight_durs, origin, dest, air_time, everything())
# Calculate air_time_diff
(flight_durs <- mutate(flight_durs, air_time_diff = arr_time_mins - dep_time_mins))
# Check if it worked. Are there negatives?
arrange(flight_durs, air_time_diff)
# There are, so flights that go overnight are incorrect. Also, timezones could cause problems

# 3
# SHould be difference between dep time and scheduled dep time
flights_deptime <- 
  mutate(
    flights,
    dep_time_mins = time_to_mins(dep_time),
    sched_dep_time_mins = time_to_mins(sched_dep_time),
    dep_delay_mins = dep_time_mins - sched_dep_time_mins
  )
# Have same issue that overnight delays appear as <= 0
```

# Exercises (cont.)
```{r}
# 4
(most_delayed <- select(
  mutate(
    flights,
    dep_delay_rank = min_rank(desc(dep_delay))
  ),
  dep_delay_rank,
  dep_delay,
  everything()
  )
 )
arrange(most_delayed, dep_delay)
# Only grab the 50 most delayed (there are no repeats in the top 10)
(top_50 <- arrange(
  filter(most_delayed, dep_delay_rank <= 50),
  dep_delay_rank)
)

# 5
1:3 + 1:10
# keeps cycling 1:3 until reach 10
```

# Grouped Summaries
```{r}
summarise(flights, delay = mean(dep_delay, na.rm = TRUE))
by_day <- group_by(flights, year, month, day)
summarize(by_day, delay = mean(dep_delay, na.rm = TRUE))

# Group flights by destination
by_dest <- group_by(flights, dest)
# Summarize distance, avg. delay, number of flights
(delays <- summarize(
  by_dest,
  count = n(),
  dist = mean(distance, na.rm = TRUE),
  delay = mean(arr_delay, na.rm = TRUE)
))
# Honolulu is quite far away from all others
arrange(delays, desc(dist))
# Ignore destinations that rarely occur
arrange(delays, count)
# Filter to remove noise (I.E. Honolulu and destinations with a very small number of flights)
(delays <- filter(delays, count > 20, dest != "HNL"))

# Visualize the data
ggplot(data = delays, mapping = aes(x = dist, y = delay)) +
  geom_point(aes(size = count), alpha = 1/3) +
  geom_smooth(se = FALSE)

# Do the same thing using pipes
# Note: x %>% f(y) == f(x, y) and x %>% f(y) %>% g(z) == g(f(x, y), z)
(delays <- flights %>%
  group_by(dest) %>%
  summarize(
    count = n(),
    dist = mean(distance, na.rm = TRUE),
    delay = mean(arr_delay, na.rm = TRUE)
  ) %>%
  filter(count > 20, dest != "HNL") %>%
  arrange(desc(delay))
)

# Reason for using na.rm
flights %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay))
# Fixed
flights %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay, na.rm = TRUE))

# Remove cancelled flights from the data set
not_cancelled <- flights %>%
  filter(!is.na(dep_delay), !is.na(arr_delay))

not_cancelled %>%
  group_by(year, month, day) %>%
  summarize(mean = mean(dep_delay))
```

# Grouped Summaries (cont.)
```{r}
# Find individual planes (identified by tail num) and their average delays
delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarize(
    delay = mean(arr_delay)
  )

ggplot(data = delays, mapping = aes(x = delay)) +
  geom_freqpoly(binwidth = 10)

# Try with number of flights vs avg delay
delays <- not_cancelled %>%
  group_by(tailnum) %>%
  summarize(
    delay = mean(arr_delay),
    n = n()
  )

# We see that variation decreases as sample size increases
ggplot(data = delays, mapping = aes(x = n, y = delay)) +
  geom_point(alpha = 1/10)
```

